import axios from 'axios';

/**
 * 环境检测和配置
 */
const isProduction = process.env.NODE_ENV === 'production' || 
                    window.location.hostname === 'zhangtao.live' ||
                    window.location.hostname.includes('zhangtao.live');

const baseURL = isProduction ? 'http://zhangtao.live:5001' : '';

console.log('当前环境:', isProduction ? '生产环境' : '开发环境');
console.log('API BaseURL:', baseURL || '使用代理');

/**
 * 创建 axios 实例，配置基础URL和请求选项
 * 开发环境: 使用相对路径，让 React 代理处理
 * 生产环境: 使用完整的线上API地址
 */
const api = axios.create({
  baseURL: baseURL,
  timeout: 0,
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
});

/**
 * 响应拦截器
 * - 自动提取响应数据
 * - 统一处理错误
 */
api.interceptors.response.use(
  response => {
    // 记录原始响应
    console.log('API Response Headers:', response.headers);
    console.log('API Response Type:', typeof response.data);
    console.log('API Response:', response.data);
    
    // 确保响应数据是对象而不是字符串
    const data = response.data;
    if (typeof data === 'string') {
      try {
        const parsedData = JSON.parse(data);
        console.log('Parsed JSON data:', parsedData);
        return parsedData;
      } catch (e) {
        console.error('Failed to parse response as JSON:', e);
        return data;
      }
    }
    return data;
  },
  error => {
    console.error('API Error:', error);
    return Promise.reject(error.response?.data || error);
  }
);

/**
 * 股票数据相关API
 */
export const stockApi = {
  /**
   * 获取所有股票代码
   * @returns {Promise<{history: string[], real: string[]}>} 历史和实盘股票代码列表
   */
  fetchStockCodes: () => {
    return api.get('/stock_codes');
  },

  /**
   * 获取股票数据，支持分页和过滤
   * @param {Object} params 查询参数
   * @param {string} params.code 股票代码
   * @param {boolean} params.is_real 是否使用实盘数据
   * @param {number} params.page 页码
   * @param {number} params.page_size 每页记录数
   * @param {string} [params.start_date] 开始日期 (YYYY-MM-DD HH:mm:ss)
   * @param {string} [params.end_date] 结束日期 (YYYY-MM-DD HH:mm:ss)
   * @returns {Promise<Object>} 股票数据和分页信息
   */
  fetchStockData: (params) => {
    console.log('Calling fetchStockData with params:', params);
    return api.get('/stock_data', { params });
  }
};

/**
 * 股票信息管理API
 */
export const stockInfoApi = {
  /**
   * 获取所有股票信息
   * @returns {Promise<Array>} 股票信息列表
   */
  getAllStockInfo: () => {
    return api.get('/stock_info');
  },

  /**
   * 获取单个股票信息
   * @param {string} code 股票代码
   * @returns {Promise<Object>} 股票信息
   */
  getStockInfo: (code) => {
    return api.get(`/stock_info/${code}`);
  },

  /**
   * 添加新的股票信息
   * @param {Object} stockInfo 股票信息
   * @returns {Promise<Object>} 添加的股票信息
   */
  addStockInfo: (stockInfo) => {
    return api.post('/stock_info', stockInfo);
  },

  /**
   * 更新股票信息
   * @param {string} code 股票代码
   * @param {Object} stockInfo 更新的股票信息
   * @returns {Promise<Object>} 更新后的股票信息
   */
  updateStockInfo: (code, stockInfo) => {
    return api.put(`/stock_info/${code}`, stockInfo);
  },

  /**
   * 删除股票信息
   * @param {string} code 股票代码
   * @returns {Promise<Object>} 操作结果
   */
  deleteStockInfo: (code) => {
    return api.delete(`/stock_info/${code}`);
  },

  /**
   * 初始化股票信息数据
   * @returns {Promise<Object>} 初始化结果
   */
  initializeStockInfo: () => {
    return api.post('/stock_info/init');
  }
};

/**
 * 股票组合管理API
 */
export const stockGroupApi = {
  /**
   * 获取所有股票组合
   * @returns {Promise<Array>} 股票组合列表
   */
  getAllStockGroups: () => {
    return api.get('/stock_groups');
  },

  /**
   * 获取单个股票组合
   * @param {number} groupId 组合ID
   * @returns {Promise<Object>} 股票组合信息
   */
  getStockGroup: (groupId) => {
    return api.get(`/stock_groups/${groupId}`);
  },

  /**
   * 添加新的股票组合
   * @param {Object} group 股票组合信息
   * @param {string} group.name 组合名称
   * @param {Array<string>} group.codes 股票代码列表
   * @returns {Promise<Object>} 添加的股票组合信息
   */
  addStockGroup: (group) => {
    return api.post('/stock_groups', group);
  },

  /**
   * 更新股票组合
   * @param {number} groupId 组合ID
   * @param {Object} group 更新的股票组合信息
   * @param {string} group.name 组合名称
   * @param {Array<string>} group.codes 股票代码列表
   * @returns {Promise<Object>} 更新后的股票组合信息
   */
  updateStockGroup: (groupId, group) => {
    return api.put(`/stock_groups/${groupId}`, group);
  },

  /**
   * 删除股票组合
   * @param {number} groupId 组合ID
   * @returns {Promise<Object>} 操作结果
   */
  deleteStockGroup: (groupId) => {
    return api.delete(`/stock_groups/${groupId}`);
  }
};

/**
 * 交易策略相关API
 */
export const strategyApi = {
  /**
   * 执行回测策略
   * @param {Object} params 策略参数
   * @param {boolean} params.ischeckhs300 是否考虑沪深300
   * @param {number} params.hs300_limit 沪深300限制天数
   * @param {string} params.backCycle 回测周期 ("day", "5T", "15T", "30T", "60T")
   * @param {string[]} params.codes 股票代码列表
   * @param {number} params.increaseday_range 涨幅天数范围
   * @param {number} params.highday_range 高点天数范围
   * @param {number} params.lowday_range 低点天数范围
   * @param {number} params.sortType 排序类型 (1: 涨跌幅, 2: 偏离均线幅度)
   * @param {number} params.tradeType 交易策略 (1-4)
   * @param {boolean} [params.isReal=false] 是否使用实盘数据
   * @param {string} [params.startDate] 回测开始日期 (YYYY-MM-DD HH:mm:ss)
   * @returns {Promise<{
   *   trade_log: Array<{date: string, type: string, price: number, code: string, desc?: string}>,
   *   cumulative_returns: Array<{date: string, cumulative_return: number}>
   * }>} 回测结果
   */
  runBacktest: (params) => {
    return api.post('/back', params);
  }
};

// 参数优化API
export const optimizationApi = {
  // 运行参数优化
  runOptimization: async (params) => {
    try {
      // 使用环境检测的baseURL
      const url = isProduction ? 'http://zhangtao.live:5001/optimization/run' : '/optimization/run';
      const response = await axios.post(url, params, {
        headers: {
          'Content-Type': 'application/json'
        }
      });
      return response.data;
    } catch (error) {
      console.error('参数优化请求失败:', error);
      throw error;
    }
  },
  
  // 保存优化结果作为策略参数
  saveOptimizationResult: async (result) => {
    try {
      const saveData = {
        name: `优化结果_${new Date().toISOString().slice(0, 10)}`,
        parameters: result.parameters
      };
      // 使用环境检测的baseURL
      const url = isProduction ? 'http://zhangtao.live:5001/optimization/save' : '/optimization/save';
      const response = await axios.post(url, saveData, {
        headers: {
          'Content-Type': 'application/json'
        }
      });
      return response.data;
    } catch (error) {
      console.error('保存优化结果失败:', error);
      throw error;
    }
  }
};

/**
 * 策略组合管理API
 */
export const strategyCombinationApi = {
  /**
   * 获取所有策略组合
   * @returns {Promise<Array>} 策略组合列表
   */
  getAllCombinations: () => {
    return api.get('/strategy_combinations');
  },

  /**
   * 获取单个策略组合
   * @param {number} combinationId 组合ID
   * @returns {Promise<Object>} 策略组合信息
   */
  getCombination: (combinationId) => {
    return api.get(`/strategy_combinations/${combinationId}`);
  },

  /**
   * 添加新的策略组合
   * @param {Object} combination 策略组合信息
   * @param {string} combination.name 组合名称
   * @param {Array<Object>} combination.strategies 策略列表
   * @returns {Promise<Object>} 添加的策略组合信息
   */
  addCombination: (combination) => {
    return api.post('/strategy_combinations', combination);
  },

  /**
   * 更新策略组合
   * @param {number} combinationId 组合ID
   * @param {Object} combination 更新的策略组合信息
   * @param {string} combination.name 组合名称
   * @param {Array<Object>} combination.strategies 策略列表
   * @returns {Promise<Object>} 更新后的策略组合信息
   */
  updateCombination: (combinationId, combination) => {
    return api.put(`/strategy_combinations/${combinationId}`, combination);
  },

  /**
   * 删除策略组合
   * @param {number} combinationId 组合ID
   * @returns {Promise<Object>} 操作结果
   */
  deleteCombination: (combinationId) => {
    return api.delete(`/strategy_combinations/${combinationId}`);
  },

  /**
   * 获取策略组合的持仓情况
   * @param {number} combinationId 组合ID
   * @param {string} startDate 开始时间（可选）
   * @param {boolean} isReal 是否使用实盘数据（可选）
   * @returns {Promise<Object>} 持仓信息
   */
  getCombinationHoldings: (combinationId, startDate = null, isReal = null) => {
    const params = {};
    if (startDate) {
      params.start_date = startDate;
    }
    if (isReal !== null) {
      params.isReal = isReal.toString();
    }
    return api.get(`/strategy_combinations/${combinationId}/holdings`, { params });
  },

  /**
   * 运行策略组合回测
   * @param {number} combinationId 组合ID
   * @param {Object} params 回测参数
   * @param {string} [params.start_date] 开始日期 (YYYY-MM-DD HH:mm:ss)
   * @param {string} [params.end_date] 结束日期 (YYYY-MM-DD HH:mm:ss)
   * @returns {Promise<Object>} 回测结果
   */
  runCombinationBacktest: (combinationId, params = {}) => {
    console.log(`调用API: /strategy_combinations/${combinationId}/backtest, 参数:`, params);
    // 确保参数是对象且非空
    const validParams = typeof params === 'object' && params !== null ? params : {};
    // 使用环境检测的baseURL
    const url = isProduction ? `http://zhangtao.live:5001/strategy_combinations/${combinationId}/backtest` : `/strategy_combinations/${combinationId}/backtest`;
    return axios.post(url, validParams, {
      headers: {
        'Content-Type': 'application/json'
      }
    }).then(response => response.data);
  }
};

/**
 * 实盘数据管理API
 */
export const realStockDataApi = {
  /**
   * 拉取所有实盘股票数据
   * @returns {Promise<Object>} 操作结果
   */
  pullAllRealStockData: () => {
    return api.post('/pullAllRealStockData');
  },

  /**
   * 获取实盘数据更新状态
   * @returns {Promise<Object>} 状态信息
   */
  getStatus: () => {
    return api.get('/realStockDataStatus');
  },

  /**
   * 停止实盘数据更新
   * @returns {Promise<Object>} 操作结果
   */
  stopUpdate: () => {
    return api.post('/stopRealStockDataUpdate');
  }
};

export const stockDataIntegrityApi = {
  /**
   * 检查数据完整性，支持is_real和start_date参数
   * @param {boolean} isReal 是否实盘
   * @param {string} startDate 起始日期（可选，格式YYYY-MM-DD或YYYY-MM-DD HH:mm:ss）
   * @returns {Promise<Object>} 缺失和重复明细
   */
  checkIntegrity: (isReal = true, startDate = null) => {
    const params = { is_real: isReal };
    if (startDate) params.start_date = startDate;
    return api.get('/check_integrity', { params });
  }
};

// 为了向后兼容，保留原有导出
export const fetchStockCodes = stockApi.fetchStockCodes;
export const fetchStockData = stockApi.fetchStockData;
export const runBacktest = strategyApi.runBacktest;

export const sync5mToRealgo5mApi = {
  /**
   * 同步data/5m到data/realgo_5m，start_date为必选
   * @param {string} startDate 起始日期（YYYY-MM-DD或YYYY-MM-DD HH:mm:ss）
   * @returns {Promise<Object>} 同步结果
   */
  sync: (startDate) => {
    return api.post('/sync_5m_to_realgo_5m', { start_date: startDate });
  }
};

export default api; 